﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Linq.Expressions;
using Sisocana.Core;
using Sisocana.Core.Models;
using Sisocana.Core.Interfaces;
using Sisocana.Dal.EntityModels;
using Sisocana.Dal;
using Sisocana.Dal.Interfaces;
using System.Data;

namespace Sisocana.Core
{
    public class ImagenAsociadoService : ServiceBase<IImagenAsociadoModel>, IImagenAsociadoService
    {
        public ImagenAsociadoService()
            : this(new ImagenAsociadoRepository())
        {
        }

        private IImagenAsociadoRepository _imgRepository;

        public ImagenAsociadoService(IImagenAsociadoRepository imgRepository)
        {
            _imgRepository = imgRepository ?? new ImagenAsociadoRepository();
        }

        public void createImagenAsociadoMapperEF2Model()
        {
            AutoMapper.Mapper.CreateMap<ImagenAsociado, ImagenAsociadoModel>()
                .ForMember(s => s.tagBusqueda, opt => opt.MapFrom(c => c.tagBusqueda.Trim()))
                .ForMember(s => s.apiKey, opt => opt.MapFrom(c => c.apiKey.Trim()))
                .ForMember(s => s.appSecret, opt => opt.MapFrom(c => c.appSecret.Trim()))
                .ForMember(s => s.ImagenAsociadoName, opt => opt.MapFrom(c => c.Imagenes.nombre.Trim()))
                .ForMember(s => s.BackgroundShellColor, opt => opt.MapFrom(c => c.autWindows.Trim()))
                .ForMember(s => s.idSitio, opt => opt.MapFrom(c => c.Sitio.id))
                .ForMember(s => s.photoGallery, opt => opt.MapFrom(c => c.photoSetId.Trim()));
        }

        public void createImagenAsociadoMapperModel2EF()
        {
            AutoMapper.Mapper.CreateMap<ImagenAsociadoModel, ImagenAsociado>()
                .ForMember(s => s.autWindows, opt => opt.MapFrom(c => c.BackgroundShellColor))
                .ForMember(s => s.Sitio.id, opt => opt.MapFrom(c => c.idSitio))
                .ForMember(s => s.photoSetId, opt => opt.MapFrom(c => c.photoGallery));
        }

        public int createUpdateImagenAsociado(ImagenAsociadoModel imgM)
        {
            //busco la asociacion 
            ImagenAsociado imgEF = _imgRepository.GetSingle(c => c.Sitio.id == imgM.idSitio);
            if (imgEF != null) 
            {
                imgEF.apiKey= imgM.apiKey;
                imgEF.appSecret = imgM.appSecret;
                imgEF.cantVisualizar = imgM.cantVisualizar;
                imgEF.autWindows = imgM.BackgroundShellColor;
                imgEF.tagBusqueda = imgM.tagBusqueda;
                imgEF.width = imgM.width;
                imgEF.heigth = imgM.heigth;
                imgEF.photoSetId = imgM.photoGallery;

                try
                {
                    _imgRepository.Save();
                    return 0;
                }
                catch (Exception e)
                {
                    return e.InnerException.GetHashCode();
                }            
            }

            else
            {
                ImagenAsociado imgAdd = new ImagenAsociado();
                imgAdd.apiKey= imgM.apiKey;
                imgAdd.appSecret = imgM.appSecret;
                imgAdd.cantVisualizar = imgM.cantVisualizar;
                imgAdd.autWindows = imgM.BackgroundShellColor;
                imgAdd.tagBusqueda = imgM.tagBusqueda;
                imgAdd.heigth = imgM.heigth;
                imgAdd.width = imgM.width;
                
                //SETEO A "FUEGO" EL ALBUM DESP VEO. ya que no es NULLABLE
                imgAdd.photoSetId = "No se usa";

                FuenteRepository _fuenteRepository = new FuenteRepository();
                IList<Fuente> fuentesEF = _fuenteRepository.GetAll();
                IEnumerable<Imagenes> listrssEF = fuentesEF.OfType<Imagenes>();

                //Siempre selecciona un nombre desde la interfaz
                Imagenes imagenes = listrssEF.AsQueryable<Imagenes>().Where(c => c.nombre.Trim() == imgM.ImagenAsociadoName.Trim()).First();

                SiteRepository _SiteRepository = new SiteRepository();
                Sitio sitEF = _SiteRepository.GetSingle(c => c.id == imgM.idSitio);

                imgAdd.Sitio = sitEF;
                imgAdd.Imagenes = imagenes;

                _imgRepository.Add(imgAdd);

                try
                {
                    _imgRepository.Save();
                    return 0;
                }
                catch (Exception e)
                {
                    return e.InnerException.GetHashCode();
                }
            }
        }

        public ImagenAsociadoModel GetSingle(Expression<Func<ImagenAsociadoModel, bool>> whereCondition)
        {


            createImagenAsociadoMapperEF2Model();

            IList<ImagenAsociado> imgAEF = _imgRepository.GetAll();
            List<ImagenAsociadoModel> imgA = new List<ImagenAsociadoModel>();

            imgA = AutoMapper.Mapper.Map(imgAEF, imgA);

            IQueryable<ImagenAsociadoModel> imgRet = imgA.AsQueryable<ImagenAsociadoModel>().Where(whereCondition);

            List<ImagenAsociadoModel> ret = imgRet.ToList();

            if (ret.Count == 0)
                return null;

            return ret.First();
        }
        
        public void Add(ImagenAsociadoModel entity)
        {
            throw new NotImplementedException();
        }

        public void Delete(ImagenAsociadoModel entity)
        {
            throw new NotImplementedException();
        }

        public void Update(ImagenAsociadoModel entity)
        {
            throw new NotImplementedException();
        }

        public IList<ImagenAsociadoModel> GetAll(Expression<Func<ImagenAsociadoModel, bool>> whereCondition)
        {
            createImagenAsociadoMapperEF2Model();

            IList<ImagenAsociado> imgAEF = _imgRepository.GetAll();
            List<ImagenAsociadoModel> imgA = new List<ImagenAsociadoModel>();
            imgA = AutoMapper.Mapper.Map(imgAEF, imgA);
            IQueryable<ImagenAsociadoModel> imgRet = imgA.AsQueryable<ImagenAsociadoModel>().Where(whereCondition);
            return imgRet.ToList();
        }

        IList<ImagenAsociadoModel> IService<ImagenAsociadoModel>.GetAll()
        {
            throw new NotImplementedException();
        }

        public IQueryable<ImagenAsociadoModel> Query(Expression<Func<ImagenAsociadoModel, bool>> whereCondition)
        {
            throw new NotImplementedException();
        }

        public long Count(Expression<Func<ImagenAsociadoModel, bool>> whereCondition)
        {
            throw new NotImplementedException();
        }
    }

}


